home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 98 / Skunkware 98.iso / osr5 / devtools / dejagnu-971222 / usr / local / share / dejagnu / libgloss.exp < prev    next >
Encoding:
Text File  |  1998-03-22  |  17.0 KB  |  740 lines
  1. # Copyright (C) 92, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
  2.  
  3. # This program is free software; you can redistribute it and/or modify
  4. # it under the terms of the GNU General Public License as published by
  5. # the Free Software Foundation; either version 2 of the License, or
  6. # (at your option) any later version.
  7. # 
  8. # This program is distributed in the hope that it will be useful,
  9. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  10. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11. # GNU General Public License for more details.
  12. # 
  13. # You should have received a copy of the GNU General Public License
  14. # along with this program; if not, write to the Free Software
  15. # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 
  16.  
  17. # Please email any bugs, comments, and/or additions to this file to:
  18. # bug-dejagnu@prep.ai.mit.edu
  19.  
  20. # This file was written by Rob Savoye. (rob@cygnus.com)
  21.  
  22. # this contains a list of gcc options and their respective directories.
  23.  
  24. #
  25. # Find the pieces of libgloss for testing the GNU development tools
  26. # needed to link a set of object files into an executable.
  27. # This usually means setting the -L and -B paths correctly.
  28. #
  29. proc libgloss_link_flags { args } {
  30.     global target_cpu
  31.     global srcdir
  32.  
  33.     # libgloss doesn't work native
  34.     if [isnative] {
  35.     return ""
  36.     }
  37.  
  38.     # if we're on a remote host, we can't search for the file, so we can only
  39.     # use an installed compiler, so we don't add any paths here.
  40.     if [is_remote host] {
  41.     return ""
  42.     }
  43.  
  44.     set gccpath "[get_multilibs]"
  45.  
  46.     # map the target_cpu to the proper libgloss directory. unfortunately, these
  47.     # directory names are hardcoded into libgloss.
  48.     switch -glob -- $target_cpu {
  49.     "sparclite" {
  50.         set cpu sparc
  51.     }
  52.     "sparclet" {
  53.         set cpu sparc
  54.     }
  55.     "hppa*" {
  56.         set cpu pa
  57.     }
  58.     "mips*" {
  59.         set cpu mips
  60.     }
  61.     "powerpc*" {
  62.         set cpu rs6000
  63.     }
  64.     default {
  65.         set cpu $target_cpu
  66.     }
  67.     }
  68.  
  69.     set gloss_srcdir ""
  70.     # look for the libgloss srcdir sp we can find the linker scripts
  71.     set gloss_srcdir [lookfor_file ${srcdir} libgloss/$cpu]
  72.  
  73.     # set the proper paths for gcc if the target subdir exists, else assume we
  74.     # have no libgloss support for this target.
  75.     if { $gloss_srcdir == "" } {
  76.     return ""
  77.     }
  78.     if [file exists $gccpath/libgloss/$cpu] {
  79.     verbose "Libgloss path is $gccpath/libgloss/$cpu" 2
  80.     return "-B$gccpath/libgloss/$cpu/ -L$gccpath/libgloss/$cpu -L$gloss_srcdir"
  81.     } else {
  82.     verbose -log "No libgloss support for this target." 2
  83.     return "-L$gloss_srcdir"
  84.     }
  85. }
  86.  
  87. # There aren't any, but we'll be orthogonal here.
  88.  
  89. proc libgloss_include_flags { args } {
  90.     return ""
  91. }
  92.  
  93. #
  94. # Find the newlib libraries in the current source tree.
  95. #
  96. proc newlib_link_flags { args } {
  97.     global base_dir
  98.  
  99.     # libgloss doesn't work native
  100.     if [isnative] {
  101.     return ""
  102.     }
  103.  
  104.     # if we're on a remote host, we can't search for the file, so we can only
  105.     # use an installed compiler, so we don't add any paths here.
  106.     if [is_remote host] {
  107.     return ""
  108.     }
  109.  
  110.     set ld_script_path [lookfor_file ${base_dir} "ld/ldscripts"];
  111.     if { $ld_script_path != "" } {
  112.     set result "-L[file dirname $ld_script_path]"
  113.     } else {
  114.     set result ""
  115.     }
  116.  
  117.     set gccpath "[get_multilibs]"
  118.  
  119.     verbose "Looking for $gccpath/newlib"
  120.     if [file exists $gccpath/newlib] {
  121.     verbose "Newlib path is $gccpath/newlib"
  122.     return "$result -B$gccpath/newlib/ -L$gccpath/newlib"
  123.     } else {
  124.     verbose "No newlib support for this target"
  125.     return "$result"
  126.     }
  127. }
  128.  
  129. proc newlib_include_flags { args } {
  130.     global srcdir
  131.  
  132.     if [isnative] {
  133.     return ""
  134.     }
  135.  
  136.     if [is_remote host] {
  137.     return ""
  138.     }
  139.  
  140.     set gccpath "[get_multilibs]"
  141.  
  142.     if [file exists $gccpath/newlib] {
  143.     verbose "Newlib path is $gccpath/newlib"
  144.  
  145.     set newlib_dir [lookfor_file ${srcdir} newlib/libc/include/assert.h]
  146.     if { ${newlib_dir} != "" } {
  147.         set newlib_dir [file dirname ${newlib_dir}]
  148.     }
  149.     return " -I$gccpath/newlib/targ-include -I${newlib_dir}"
  150.     } else {
  151.     verbose "No newlib support for this target"
  152.     }
  153. }
  154.  
  155. proc libio_include_flags { args } {
  156.     global srcdir
  157.     global base_dir
  158.  
  159.     if [is_remote host] {
  160.     return ""
  161.     }
  162.  
  163.     set gccpath "[get_multilibs]"
  164.  
  165.     if { $gccpath == "" } {
  166.     set gccpath [file dirname [file dirname ${base_dir}]]
  167.     }
  168.  
  169.     set libio_bin_dir [lookfor_file ${gccpath} libio/_G_config.h];
  170.  
  171.     # linux doesn't build _G_config.h and the test above fails, so
  172.     # we search for iostream.list too.
  173.     if { $libio_bin_dir == "" } {
  174.     set libio_bin_dir [lookfor_file ${gccpath} libio/iostream.list];
  175.     }
  176.  
  177.     set libio_src_dir [lookfor_file ${srcdir} libio/Makefile.in]
  178.     if { $libio_bin_dir != "" && $libio_src_dir != "" } {
  179.     set libio_src_dir [file dirname ${libio_src_dir}]
  180.     set libio_bin_dir [file dirname ${libio_bin_dir}];
  181.     return " -I${libio_src_dir} -I${libio_bin_dir}"
  182.     } else {
  183.     return ""
  184.     }
  185. }
  186.  
  187. proc libio_link_flags { args } {
  188.     if [is_remote host] {
  189.     return ""
  190.     }
  191.  
  192.     set gccpath "[get_multilibs]"
  193.  
  194.     set libio_dir [lookfor_file ${gccpath} libio/libio.a]
  195.     if { $libio_dir != "" } {
  196.     return "-L[file dirname ${libio_dir}]"
  197.     } else {
  198.     return ""
  199.     }
  200. }
  201.  
  202. proc g++_include_flags { args } {
  203.     global srcdir
  204.  
  205.     if [is_remote host] {
  206.     return ""
  207.     }
  208.  
  209.     set gccpath [get_multilibs]
  210.     set libio_dir ""
  211.     set flags ""
  212.  
  213.     set dir [lookfor_file ${srcdir} libg++]
  214.     if { ${dir} != "" } {
  215.     append flags "-I${dir} -I${dir}/src "
  216.     }
  217.     set dir [lookfor_file ${srcdir} libstdc++]
  218.     if { ${dir} != "" } {
  219.     append flags "-I${dir} -I${dir}/stl"
  220.     }
  221.     return "$flags"
  222. }
  223.  
  224. proc g++_link_flags { args } {
  225.     global srcdir
  226.     global ld_library_path
  227.  
  228.     set gccpath [get_multilibs];
  229.     set libio_dir ""
  230.     set flags ""
  231.     set ld_library_path "."
  232.  
  233.     if { $gccpath != "" } {
  234.     if [file exists "${gccpath}/libg++/libg++.a"] {
  235.         append flags "-L${gccpath}/libg++ "
  236.         append ld_library_path ":${gccpath}/libg++"
  237.     }
  238.     if [file exists "${gccpath}/libstdc++/libstdc++.a"] {
  239.         append flags "-L${gccpath}/libstdc++ "
  240.         append ld_library_path ":${gccpath}/libstdc++"
  241.     }
  242.     if [file exists "${gccpath}/libiberty/libiberty.a"] {
  243.         append flags "-L${gccpath}/libiberty "
  244.     }
  245.     if [file exists "${gccpath}/librx/librx.a"] {
  246.         append flags "-L${gccpath}/librx "
  247.     }
  248.     } else {
  249.     global objdir;
  250.  
  251.     set libgpp [lookfor_file ${objdir} libg++];
  252.     if { $libgpp != "" } {
  253.         append flags "-L${libgpp} ";
  254.         append ld_library_path ":${libgpp}"
  255.     }
  256.     set libstdcpp [lookfor_file ${objdir} libstdc++];
  257.     if { $libstdcpp != "" } {
  258.         append flags "-L${libstdcpp} ";
  259.         append ld_library_path ":${libstdcpp}"
  260.     }
  261.     set libiberty [lookfor_file ${objdir} libiberty];
  262.     if { $libiberty != "" } {
  263.         append flags "-L${libiberty} ";
  264.     }
  265.     set librx [lookfor_file ${objdir} librx];
  266.     if { $librx != "" } {
  267.         append flags "-L${librx} ";
  268.     }
  269.     }
  270.     return "$flags"
  271. }
  272.  
  273. proc libstdc++_include_flags { args } {
  274.     global srcdir
  275.  
  276.     if [is_remote host] {
  277.     return ""
  278.     }
  279.  
  280.     set gccpath [get_multilibs]
  281.     set libio_dir ""
  282.     set flags ""
  283.  
  284.     set dir [lookfor_file ${srcdir} libstdc++]
  285.     if { ${dir} != "" } {
  286.     append flags "-I${dir} -I${dir}/stl"
  287.     }
  288.     return "$flags"
  289. }
  290.  
  291. proc libstdc++_link_flags { args } {
  292.     global srcdir
  293.     global ld_library_path
  294.  
  295.     set gccpath [get_multilibs];
  296.     set libio_dir ""
  297.     set flags ""
  298.  
  299.     if { $gccpath != "" } {
  300.     if [file exists "${gccpath}/libstdc++/libstdc++.a"] {
  301.         append flags "-L${gccpath}/libstdc++ "
  302.         append ld_library_path ":${gccpath}/libstdc++"
  303.     }
  304.     if [file exists "${gccpath}/libiberty/libiberty.a"] {
  305.         append flags "-L${gccpath}/libiberty "
  306.     }
  307.     if [file exists "${gccpath}/librx/librx.a"] {
  308.         append flags "-L${gccpath}/librx "
  309.     }
  310.     } else {
  311.     global objdir;
  312.  
  313.     set libstdcpp [lookfor_file ${objdir} libstdc++];
  314.     if { $libstdcpp != "" } {
  315.         append flags "-L${libstdcpp} ";
  316.         append ld_library_path ":${libstdcpp}"
  317.     }
  318.     set libiberty [lookfor_file ${objdir} libiberty];
  319.     if { $libiberty != "" } {
  320.         append flags "-L${libiberty} ";
  321.     }
  322.     set librx [lookfor_file ${objdir} librx];
  323.     if { $librx != "" } {
  324.         append flags "-L${librx} ";
  325.     }
  326.     }
  327.     return "$flags"
  328. }
  329.  
  330. #
  331. # Get the list of directories and -m options for gcc. This is kinda bogus that
  332. # generic testing software needs support for gcc hardwired in, but to make 
  333. # testing the GNU tools work right, there didn't seem to be any other way.
  334. #
  335.  
  336. proc get_multilibs { args } {
  337.     global target_alias
  338.     global board
  339.     global board_info
  340.  
  341.     # if we're on a remote host, we can't search for the file, so we can only
  342.     # use an installed compiler, so we don't add any paths here.
  343.     if [is_remote host] {
  344.     return ""
  345.     }
  346.  
  347.     if [info exists board] {
  348.     set target_board $board;
  349.     } else {
  350.     set target_board [target_info name];
  351.     }
  352.  
  353.     if { [llength $args] == 0 } {
  354.     if [board_info $target_board exists multitop] {
  355.         return "[board_info $target_board multitop]";
  356.     }
  357.  
  358.     set board_info($target_board,multitop) ""
  359.     }
  360.  
  361.     if { [board_info $target_board exists compiler] } {
  362.     set compiler [board_info $target_board compiler];
  363.     } else {
  364.     set compiler [find_gcc];
  365.     }
  366.  
  367.     if { $compiler == "" } {
  368.     return "";
  369.     }
  370.  
  371.     foreach x "$compiler" {
  372.     if [regexp "^-B" "$x"] {
  373.         regsub "^-B" "$x" "" comp_base_dir;
  374.         set comp_base_dir [file dirname $comp_base_dir];
  375.         break;
  376.     }
  377.     }
  378.     if { [llength $args] > 0 } {
  379.     set mopts [lindex $args 0];
  380.     } else {
  381.     if { [board_info $target_board exists multilib_flags] } {
  382.         set mopts [board_info $target_board multilib_flags];
  383.     } else {
  384.         set mopts ""
  385.     }
  386.     }
  387.  
  388.     regsub "^-" $mopts "" moptions
  389.     regsub -all " -" $moptions " " dirty_moptions
  390.     set moptions ""
  391.     foreach x [split $dirty_moptions " "] {
  392.     if { $x != "" && [lsearch -exact $moptions $x] < 0 } {
  393.         lappend moptions $x
  394.     }
  395.     }
  396.  
  397.     regexp "/.* " $compiler compiler
  398.     set compiler [string trimright $compiler " "]
  399.     verbose "compiler is $compiler"
  400.  
  401.     if ![info exists comp_base_dir] {
  402.     set comp_base_dir [which $compiler];
  403.  
  404.     if { $comp_base_dir == 0 } {
  405.         return "";
  406.     }
  407.  
  408.     set comp_base_dir [file dirname [file dirname $comp_base_dir]];
  409.     } else {
  410.     if { [which $compiler] == 0 } {
  411.         return "";
  412.     }
  413.     }
  414.  
  415.     # extract the options and their directory names as know by gcc
  416.     foreach i "[exec $compiler --print-multi-lib]" {
  417.     set opts ""
  418.     set dir ""
  419.     regexp -- "\[a-z0-9/\.-\]*;" $i dir
  420.     set dir [string trimright $dir "\;@"]
  421.     regexp -- "\;@*\[\@a-zA-Z0-9/\.-\]*" $i opts
  422.     set opts [split [string trimleft $opts "\;@"] "@"]
  423.     lappend multilibs "$dir {$opts }"
  424.     }
  425.  
  426.  
  427.     # search for the top level multilib directory
  428.     set multitop [lookfor_file "${comp_base_dir}" "${target_alias}"]
  429.     if { $multitop == "" } {
  430.     set multitop [lookfor_file "${comp_base_dir}" "libraries"]
  431.     if { $multitop == "" } {
  432.         set multitop "[lookfor_file ${comp_base_dir} gcc/xgcc]"
  433.         if { $multitop != "" } {
  434.         set multitop [file dirname [file dirname $multitop]];
  435.         } else {
  436.         return ""
  437.         }
  438.     }
  439.     }
  440.  
  441.     # make a list of -m<foo> options from the various compiler config variables
  442.     set gccpath ""
  443.  
  444.     # compare the lists of gcc options with the list of support multilibs
  445.     verbose "Supported multilibs are: $multilibs" 3
  446.     set best 0;
  447.     foreach i "$multilibs" {
  448.     set hits 0
  449.     set opts [lindex $i 1];
  450.     if { [llength $opts] <= [llength $moptions] } {
  451.         foreach j "$moptions" {
  452.         # see if all the -m<foo> options match any of the multilibs
  453.         verbose "Looking in $i for $j" 3
  454.         if { [lsearch -exact $opts $j] >= 0 } {
  455.             incr hits
  456.         }
  457.         }
  458.  
  459.         if { $hits > $best } {
  460.         verbose "[lindex $i 0] is better, using as gcc path" 2
  461.         set gccpath "[lindex $i 0]"
  462.         set best $hits;
  463.         }
  464.     }
  465.     }
  466.     if ![info exists multitop] {
  467.     return "";
  468.     }
  469.  
  470.     verbose "gccpath is $gccpath" 3
  471.  
  472.     if [file exists $multitop/$gccpath] {
  473.     verbose "GCC path is $multitop/$gccpath" 3
  474.     if { [llength $args] == 0 } {
  475.         set board_info($target_board,multitop) "$multitop/$gccpath"
  476.     }
  477.     return "$multitop/$gccpath"
  478.     } else {
  479.     verbose "GCC path is $multitop" 3
  480.     if { [llength $args] == 0 } {
  481.         set board_info($target_board,multitop) "$multitop"
  482.     }
  483.     return "$multitop"
  484.     }
  485. }
  486.  
  487. proc find_binutils_prog { name } {
  488.     global base_dir;
  489.  
  490.     if ![is_remote host] {
  491.     
  492.     set file [lookfor_file $base_dir $name];
  493.     if { $file == "" } {
  494.         set file [lookfor_file $base_dir ${name}-new];
  495.     }
  496.     if { $file == "" } {
  497.         set file [lookfor_file $base_dir binutils/$name];
  498.     }
  499.     if { $file == "" } {
  500.         set file [lookfor_file $base_dir binutils/${name}-new];
  501.     }
  502.     if { $file != "" } {
  503.         set NAME "$file";
  504.     } else {
  505.         set NAME [transform $name];
  506.     }
  507.     } else {
  508.     set NAME [transform $name]
  509.     }
  510.     return $NAME;
  511. }
  512.  
  513. proc find_gcc {} {
  514.     global base_dir
  515.  
  516.     if ![is_remote host] {
  517.     set file [lookfor_file $base_dir xgcc];
  518.     if { $file == "" } {
  519.         set file [lookfor_file $base_dir gcc/xgcc];
  520.     }
  521.     if { $file != "" } {
  522.         set CC "$file -B[file dirname $file]/";
  523.     } else {
  524.         set CC [transform gcc];
  525.     }
  526.     } else {
  527.     set CC [transform gcc]
  528.     }
  529.     return $CC;
  530. }
  531.  
  532. proc find_g++ {} {
  533.     global base_dir
  534.  
  535.     if ![is_remote host] {
  536.     set file [lookfor_file $base_dir g++];
  537.     if { $file == "" } {
  538.         set file [lookfor_file $base_dir gcc/g++];
  539.     }
  540.     if { $file != "" } {
  541.         set CC "$file -B[file dirname $file]/";
  542.     } else {
  543.         set CC [transform g++];
  544.     }
  545.     } else {
  546.     set CC [transform g++]
  547.     }
  548.     return $CC;
  549. }
  550.  
  551. proc find_g77 {} {
  552.     global base_dir
  553.  
  554.     if ![is_remote host] {
  555.     set file [lookfor_file $base_dir g77];
  556.     if { $file == "" } {
  557.         set file [lookfor_file $base_dir gcc/g77];
  558.     }
  559.     if { $file != "" } {
  560.         set CC "$file -B[file dirname $file]/";
  561.     } else {
  562.         set CC [transform g77];
  563.     }
  564.     } else {
  565.     set CC [transform g77]
  566.     }
  567.     return $CC;
  568. }
  569.  
  570. proc process_multilib_options { args } {
  571.     global board;
  572.     global board_variant_list;
  573.     global is_gdb_remote;
  574.  
  575.     set is_gdb_remote 0;
  576.  
  577.     if [board_info $board exists multilib_flags] {
  578.     return;
  579.     }
  580.     eval add_multilib_option $args;
  581.  
  582.     set multilib_flags "";
  583.  
  584.     foreach x $board_variant_list {
  585.     regsub -all "^\[ \t\]*" "$x" "" x;
  586.     regsub -all "\[ \t\]*$" "$x" "" x;
  587.  
  588.     if { $x == "" } {
  589.         continue;
  590.     }
  591.     case $x in {
  592.         { aout } {
  593.         set_board_info obj_format "a.out";
  594.         }
  595.         { elf } {
  596.         set_board_info obj_format "elf";
  597.         }
  598.         { pe } {
  599.         set_board_info obj_format "pe";
  600.         }
  601.         { ecoff } {
  602.         set_board_info obj_format "ecoff";
  603.         }
  604.         { stabs } {
  605.         set_board_info debug_flags "-gstabs";
  606.         }
  607.         { dwarf2 } {
  608.         set_board_info debug_flags "-gdwarf2";
  609.         }
  610.         { gdb*remote } {
  611.         set is_gdb_remote 1;
  612.         }
  613.         { little*endian el EL } {
  614.         append multilib_flags " -EL";
  615.         }
  616.         { big*endian eb EB } {
  617.         append multilib_flags " -EB";
  618.         }
  619.         { "soft*float" } {
  620.         append multilib_flags " -msoft-float"
  621.         }
  622.         { "-*" } {
  623.         append multilib_flags " $x";
  624.         }
  625.         default {
  626.         append multilib_flags " -m$x";
  627.         }
  628.     }
  629.     }
  630.     set_board_info multilib_flags $multilib_flags;
  631. }
  632.  
  633. proc add_multilib_option { args } {
  634.     global board_variant_list
  635.  
  636.     if ![info exists board_variant_list] {
  637.     set board_variant_list ""
  638.     }
  639.     set board_variant_list [concat $args $board_variant_list];
  640. }
  641.  
  642. proc find_gas { } {
  643.     global base_dir
  644.  
  645.     set AS ""
  646.  
  647.     if ![is_remote host] {
  648.     set AS [lookfor_file $base_dir as-new];
  649.     if { $AS == "" } {
  650.         set AS [lookfor_file $base_dir gas/as-new];
  651.     }
  652.     }
  653.     if { $AS == "" } {
  654.     set AS [transform as];
  655.     }
  656.     return $AS;
  657. }
  658.  
  659. proc build_wrapper { gluefile } {
  660.     global libdir
  661.  
  662.     if [target_info exists wrap_m68k_aout] {
  663.     set flags "additional_flags=-DWRAP_M68K_AOUT";
  664.     set result "";
  665.     } elseif [target_info exists uses_underscores] {
  666.     set flags "additional_flags=-DUNDERSCORES";
  667.     set result "-Wl,-wrap,__exit -Wl,-wrap,_main -Wl,-wrap,_abort";
  668.     } else {
  669.     set flags "";
  670.     if [target_info exists is_vxworks] {
  671.         set flags "additional_flags=-DVXWORKS";
  672.     }
  673.     set result "-Wl,-wrap,exit -Wl,-wrap,main -Wl,-wrap,abort";
  674.     }
  675.     if [target_info exists wrap_compile_flags] {
  676.     lappend flags "additional_flags=[target_info wrap_compile_flags]";
  677.     }
  678.     if { [target_compile ${libdir}/testglue.c ${gluefile} object $flags] == "" } {
  679.     set gluefile [remote_download host ${gluefile} testglue.o];
  680.     return [list $gluefile $result];
  681.     } else {
  682.     return ""
  683.     }
  684. }
  685.  
  686.  
  687. proc winsup_include_flags { args } {
  688.     global srcdir
  689.  
  690.     if [isnative] {
  691.     return ""
  692.     }
  693.  
  694.     if [is_remote host] {
  695.     return ""
  696.     }
  697.  
  698.     set gccpath "[get_multilibs]"
  699.  
  700.     if [file exists $gccpath/winsup] {
  701.     verbose "Winsup path is $gccpath/winsup"
  702.  
  703.     set winsup_dir [lookfor_file ${srcdir} winsup/include/windows]
  704.     if { ${winsup_dir} != "" } {
  705.         set winsup_dir [file dirname ${winsup_dir}]
  706.         return " -I${winsup_dir}"
  707.     }
  708.     }
  709.     verbose "No winsup support for this target"
  710.     
  711. }
  712. #
  713. # Find the winsup libraries in the current source tree.
  714. #
  715. proc winsup_link_flags { args } {
  716.     global base_dir
  717.  
  718.     # libgloss doesn't work native
  719.     if [isnative] {
  720.     return ""
  721.     }
  722.  
  723.     # if we're on a remote host, we can't search for the file, so we can only
  724.     # use an installed compiler, so we don't add any paths here.
  725.     if [is_remote host] {
  726.     return ""
  727.     }
  728.  
  729.     set gccpath "[get_multilibs]"
  730.  
  731.     verbose "Looking for $gccpath/winsup"
  732.     if [file exists $gccpath/winsup] {
  733.     verbose "Winsup path is $gccpath/newlib"
  734.     return "-B$gccpath/winsup/ -L$gccpath/winsup"
  735.     } else {
  736.     verbose "No winsup support for this target"
  737.     return ""
  738.     }
  739. }
  740.